package com.zhulin.comassistant;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * @author ZL @朱林</a>
 * @Version 1.0
 * @Description TODO
 * @date 2021/08/09  14:18
 */
public class StringUtil {
    public static boolean isEmpty(String s) {
        return null == s || s.isEmpty();
    }

    /**
     * 检查指定的字符串列表是否不为空。
     */
    public static boolean areNotEmpty(String... values) {
        boolean result = true;
        if (values == null || values.length == 0) {
            result = false;
        } else {
            for (String value : values) {
                result &= !isEmpty(value);
            }
        }
        return result;
    }

    public static Integer stringToInt(String value) {
        Integer result = null;
        if (!isEmpty(value)) {
            try {
                result = Integer.parseInt(value);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static <T> List<T> stringSetToList(Set<T> values) {
        List<T> list = null;
        if (null != values && values.size() > 0) {
            list = new ArrayList<>(values);
        }
        return list;
    }

    public static <T> Set<T> stringListToSet(List<T> values) {
        Set<T> sets = null;
        if (null != values && values.size() > 0) {
            sets = new HashSet<>(values);
        }
        return sets;
    }

    /**
     * 将int转为低字节在前，高字节在后的byte数组
     */
    public static byte[] intToByteArrayByLow(int n) {
        byte[] bytes = new byte[4];
        bytes[0] = (byte) (n & 0xff);
        bytes[1] = (byte) (n >>> 8 & 0xff);
        bytes[2] = (byte) (n >>> 16 & 0xff);
        bytes[3] = (byte) (n >>> 24 & 0xff);
        return bytes;
    }

    /**
     * 低字节在前的方式获取int值
     */
    public static int byteArrayToIntByLow(byte[] b) {
        return byteArrayToIntByLow(b, 0);
    }

    /**
     * 低字节在前的方式获取int值
     */
    public static int byteArrayToIntByLow(byte[] b, int offset) {
        int n = 0;
        int len = b.length;
        if (len >= offset + 4) {
            // 低字节在前
            // 最右边的字节，不需要移位
            int byte0 = b[offset] & 0xff;
            // 右边第二个字节，需要左移一个字节，8位
            int byte1 = b[offset + 1] & 0xff;
            // 右边第三个字节，需要左移两个字节，16位
            int byte2 = b[offset + 2] & 0xff;
            // 最左边的字节，需要左移三哥字节，24位
            int byte3 = b[offset + 3] & 0xff;
            n = byte0 | byte1 << 8 | byte2 << 16 | byte3 << 24;
        }
        return n;
    }


    /**
     * 将short转为低字节在前，高字节在后的byte数组
     */
    public static byte[] shortToByteArrayByLow(short n) {
        byte[] bytes = new byte[4];
        bytes[0] = (byte) (n & 0xff);
        bytes[1] = (byte) (n >>> 8 & 0xff);
        return bytes;
    }
    /**
     * @param b      低字节在前
     * @return
     */
    public static short byteArrayToShortByLow(byte[] b) {
        return byteArrayToShortByLow(b,0);
    }

    /**
     * @param b      低字节在前
     * @param offset
     * @return
     */
    public static short byteArrayToShortByLow(byte[] b, int offset) {
        short n = 0;
        int len = b.length;
        if (len >= offset + 2) {
            // 低字节在前
            // 最右边的字节，不需要移位
            int byte0 = b[offset] & 0xff;
            // 右边第二个字节，需要左移一个字节，8位
            int byte1 = b[offset + 1] & 0xff;
            n = (short) (byte0 | byte1 << 8);
        }
        return n;
    }

    /**
     * long转byte[8]，低字节在前
     */
    public static byte[] longToByteArrayByLow(long n) {
        byte[] bytes = new byte[8];
        bytes[0] = (byte) (n & 0xff);
        bytes[1] = (byte) (n >>> 8 & 0xff);
        bytes[2] = (byte) (n >>> 16 & 0xff);
        bytes[3] = (byte) (n >>> 24 & 0xff);
        bytes[4] = (byte) (n >>> 32 & 0xff);
        bytes[5] = (byte) (n >>> 40 & 0xff);
        bytes[6] = (byte) (n >>> 48 & 0xff);
        bytes[7] = (byte) (n >>> 56 & 0xff);
        return bytes;
    }

    public static long byteArrayToLongByLow(byte[] b) {
        return byteArrayToLongByLow(b,0);
    }

    /**
     * 将byte数组转为long
     */
    public static long byteArrayToLongByLow(byte[] b, int offset) {
        long n = 0;
        int len = b.length;
        if (len >= offset + 8) {
            // 低字节在前
            // 最右边的字节，不需要移位
            long byte0 = b[offset] & 0xff;
            // 右边第二个字节，需要左移一个字节，8位
            long byte1 = b[offset + 1] & 0xff;
            // 右边第三个字节，需要左移两个字节，16位
            long byte2 = b[offset + 2] & 0xff;
            // 最左边的字节，需要左移三哥字节，24位
            long byte3 = b[offset + 3] & 0xff;
            // 最左边的字节，需要左移三哥字节，32位
            long byte4 = b[offset + 4] & 0xff;
            // 最左边的字节，需要左移三哥字节，40位
            long byte5 = b[offset + 5] & 0xff;
            // 最左边的字节，需要左移三哥字节，48位
            long byte6 = b[offset + 6] & 0xff;
            // 最左边的字节，需要左移三哥字节，56位
            long byte7 = b[offset + 7] & 0xff;
            n = byte0 | byte1 << 8 | byte2 << 16 | byte3 << 24 | byte4 << 32 | byte5 << 40 | byte6 << 48 | byte7 << 56;
        }
        return n;
    }

    /**
     * float转换byte
     */
    public static byte[] floatToByteArrayByLow(float n) {
        int value = Float.floatToIntBits(n);
        return intToByteArrayByLow(value);
    }

    /**
     * 通过byte数组取得float
     */
    public static float byteArrayToFloatByLow(byte[] b) {
        return byteArrayToFloatByLow(b, 0);
    }

    /**
     * 通过byte数组取得float
     */
    public static float byteArrayToFloatByLow(byte[] b, int offset) {
        int value = byteArrayToIntByLow(b, offset);
        return Float.intBitsToFloat(value);
    }


    /**
     * float转换byte
     */
    public static byte[] doubleToByteArrayByLow(double n) {
        long value = Double.doubleToLongBits(n);
        return longToByteArrayByLow(value);
    }

    /**
     * 通过byte数组取得float
     */
    public static double byteArrayToDoubleByLow(byte[] b) {
        return byteArrayToDoubleByLow(b,0);
    }

    /**
     * 通过byte数组取得float
     */
    public static double byteArrayToDoubleByLow(byte[] b, int offset) {
        long value=byteArrayToLongByLow(b,offset);
        return Double.longBitsToDouble(value);
    }

    public static String join(final Object[] array, final String separator) {
        if (array == null) {
            return null;
        }
        return join(array, separator, 0, array.length);
    }

    public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) {
        if (array == null) {
            return null;
        }
        if (separator == null) {
            separator = "";
        }
        // endIndex - startIndex > 0:   Len = NofStrings *(len(firstString) + len(separator))
        //           (Assuming that all Strings are roughly equally long)
        final int noOfItems = endIndex - startIndex;
        if (noOfItems <= 0) {
            return "";
        }
        final StringBuilder buf = newStringBuilder(noOfItems);
        if (array[startIndex] != null) {
            buf.append(array[startIndex]);
        }
        for (int i = startIndex + 1; i < endIndex; i++) {
            buf.append(separator);
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }

    private static StringBuilder newStringBuilder(final int noOfItems) {
        return new StringBuilder(noOfItems * 16);
    }
}